home *** CD-ROM | disk | FTP | other *** search
/ PC World 2006 November / PCWorld_2006-11_cd.bin / domacnost a kancelar / findgraph / fgraph.exe / {app} / ApprSource / poli_n.cpp < prev    next >
C/C++ Source or Header  |  2005-08-29  |  12KB  |  504 lines
  1. /******************************************************************************
  2.  * Plug-In DLL Example and Template
  3.  * for use with C/C++
  4.  *
  5.  * Compile DLL with any name.
  6.  * Place it in  the program FindGraph subfolder "Appr".
  7.  * Next functions must be exported:
  8.  *        MaxOfFactors
  9.  *        Prepare
  10.  *        CalcInPoint
  11.  *        FunctionTitle
  12.  *        FunctionName 
  13.  *        FunctionString
  14.  *        ParamInfo
  15.  * 
  16.  * To test DLL, restart FundGraph, 
  17.  * start The Wizard of approximation,
  18.  * on step 2 select 'User defined function'.
  19.  * If all right, on step 3 your function will appear in list.
  20.  * 
  21.  ******************************************************************************/
  22.  
  23.  
  24. #include <windows.h>
  25. #include <tchar.h>
  26. #include <math.h>
  27. #include "poli_n.h"
  28.  
  29.  
  30. #include <stdio.h>
  31.  
  32.  
  33. // 
  34. #pragma comment(linker,"/MERGE:.rdata=.text")
  35. #pragma comment(linker,"/FILEALIGN:512 /SECTION:.text,EWRX /IGNORE:4078")
  36.  
  37. //////////////////////////////////////////////////////////////////////////////////
  38.  
  39.  
  40. HINSTANCE g_hInstance=NULL;
  41. BOOL APIENTRY DllMain( HANDLE hModule, DWORD  ul_reason_for_call, LPVOID lpReserved )
  42. {
  43.     switch (ul_reason_for_call)
  44.     {
  45.         case DLL_PROCESS_ATTACH:
  46.              g_hInstance = (HINSTANCE )hModule;
  47.              break;
  48.         case DLL_PROCESS_DETACH:
  49.              break;
  50.     }
  51.      return TRUE;
  52. }
  53.  
  54.  
  55.  
  56.  
  57. ////////////////////////////////////////////////////////////////////////////////////////////////////
  58. #define N_FACTORS 18 
  59. #define aa(i,j) pfs[i*nn+j]
  60.  
  61.  
  62. // calc f**n
  63. double PowInt( double f, int n)
  64. { 
  65.   double val=1.;
  66.   if  ( n ) for ( int i=1; i<=n; i++ )
  67.          val *= f;
  68.   return val;
  69. }
  70.  
  71.  
  72. // Calc line equations
  73. // nAppr - number equations
  74. // fs - coeffs. matrix aa(i,j)
  75. // fu - buffer to return results
  76. //
  77. void CalcEquGauss(UINT  nAppr, double *pfs, double *pfu)
  78. {
  79.   int   i, j, k,
  80.          n = nAppr,
  81.         nn = n+2;
  82.  
  83.   for (i=0; i <= n; i++)
  84.   {
  85.     for (k=n+1; k >= i; k--)
  86.          aa(i,k) /= aa(i,i);
  87.     if  (i < n)
  88.       for (j=i+1; j <= n; j++)
  89.         for (k=n+1; k >= 0; k--)
  90.              aa(j,k) -= (aa(j,i)*aa(i,k));
  91.   }
  92.  
  93.   pfu[n] = aa(n,n+1);
  94.   if  (n)
  95.   for (i=n-1; i >= 0; i-- )
  96.     for (k=i+1, pfu[i] = aa(i,n+1); k<= n; k++)
  97.              pfu[i] -= (aa(i,k)*pfu[k]);
  98. }
  99.  
  100.  
  101. // return number points with u != fNullU
  102. //
  103. int FindLimits(double &fMinU, double &fMaxU, double &fMinV, double &fMaxV,
  104.                double *pfU, double *pfV, int nPoints, double fNullU)
  105. {
  106.     int  np = 0;
  107.     for (int i=0; i<nPoints; i++)
  108.     {
  109.         double u = pfU[i],
  110.                v = pfV[i];
  111.         if  (fNullU == u) continue;
  112.         if  (np==0)
  113.         {
  114.             fMinU = fMaxU = u;
  115.             fMinV = fMaxV = v;
  116.         }
  117.         else
  118.         {
  119.             if (fMinU > u) fMinU = u;
  120.             if (fMaxU < u) fMaxU = u;
  121.             if (fMinV > v) fMinV = v;
  122.             if (fMaxV < v) fMaxV = v;
  123.         }
  124.         np++;
  125.     }
  126.     return np;
  127. }
  128.  
  129.  
  130.  
  131. //-------------------------------------------
  132. // Error of calculus
  133. //
  134. double CalcError(double *pfU, double *pfV, int nPoints, 
  135.                  double *pfFactors, int nFactors)
  136. {
  137.     if (nPoints  <= 0)
  138.         return 0.;
  139.     double fError = 0.;
  140.     for (int id=0; id < nPoints; id++ )
  141.     {
  142.         double u = pfU[id],
  143.                v = pfV[id],
  144.                v1= CalcInPoint(u, pfFactors, nFactors);
  145.         fError += (v1-v)*(v1-v);
  146.     }
  147.     fError = sqrt(fError/nPoints);
  148.     return fError;
  149. }
  150.  
  151. ////////////////////////////////////////////////////////////////////////////////////////////////////
  152. //
  153. // Return the number of factors (see function 'Prepare')
  154. // use to memory allocate for pfFactors
  155. //
  156.  
  157. //extern "C" bool __declspec( dllexport ) __stdcall TransFromDisk(char *Base, char *Disk);
  158.  
  159.  
  160. int __declspec(dllexport) __stdcall MaxOfFactors()
  161. {
  162.     return N_FACTORS;
  163. }
  164.  
  165.  
  166. //
  167. // Prepare approximation function V(U) = Function(U)
  168. //     V(U) = V0 + (U-U0)^M*(A0 + A1*U + ... +AN*U^N)
  169. // Input:
  170. // Array of points (U,V)
  171. //        fMinU, fMaxU - limits of U 
  172. //        fMinV, fMaxV - limits of V 
  173. //        pfU, pfV - array of nPoints points (U,V)
  174. //        pfW         - weight of point
  175. //      nPoints     - number of points in array 
  176. // Parameters:
  177. //        pfParams - array of parameters
  178. //        M  = pfParams[0] - pow of 
  179. //        N  = pfParams[1] - pow of polinom approximation
  180. //        U0 = pfParams[2]
  181. //        V0 = pfParams[3]
  182. //      nParams  - number of parameters in array 
  183. //
  184. // Output:
  185. // Array of factors is calculated.
  186. // This factors will be used in function CalcInPoint(U, pfFactors)
  187. //        pfFactors - array of factors, defined by user
  188. //        Notes: pfFactors[*pnFactors-1] = Error of calculus
  189. //      nFactors:
  190. //            Input  - maximum possible number of factors in array 
  191. //
  192. // return: number of factors if success, else error code
  193. //
  194. int __declspec(dllexport) __stdcall Prepare (double fMinU, double fMaxU, double fMinV, double fMaxV,
  195.                double *pfU, double *pfV, double *pfW, int nPoints, 
  196.                double *pfParams , int nParams ,
  197.                double *pfFactors, int nFactors)
  198. {
  199.     int nResult = 0;
  200.     if (nPoints < 2) // not enough points
  201.         return -1;
  202.  
  203.     if (nFactors < N_FACTORS) // not enough memory for result
  204.         return -2;
  205.  
  206.  
  207.     double fPoli = 1;
  208.     int    nAppr = 4;
  209.     double fU0   = 0,
  210.            fV0     = 0;
  211.  
  212.     if (nParams > 0) fPoli =      pfParams[0];
  213.     if (nParams > 1) nAppr = (int)pfParams[1];
  214.     if (nParams > 2) fU0   =      pfParams[2];
  215.     if (nParams > 3) fV0   =      pfParams[3];
  216.  
  217.  
  218.     if (fPoli <-5) fPoli =-5;    if (fPoli > 5) fPoli = 5;
  219.     if (nAppr < 0) nAppr = 0;    if (nAppr > 5) nAppr = 5;
  220.  
  221.  
  222.     int nPointInAppr = FindLimits(fMinU, fMaxU, fMinV, fMaxV, pfU, pfV, nPoints, fU0);
  223.     double dU = fMaxU - fMinU;
  224.     if (dU <  0.) dU = -dU;
  225.  
  226.     if (nPointInAppr < 5)
  227. //           nAppr = nPointInAppr;
  228.            nAppr = nPointInAppr-1;
  229.  
  230.     int    nn = nAppr + 2,
  231.            ns =(nAppr+1)*(nn+1);
  232.  
  233.     // nAppr < 5
  234.     double fAppr[10];
  235.  
  236.     double 
  237.            *pfs,
  238.            *pfu;
  239.     // use: aa(i,j) == pfs[i*nn+j]
  240.  
  241.     pfu = new double[nAppr+1+nPoints];//use as normed fU and coeff
  242.     pfs = new double[ns];
  243.     memset(pfs, 0, ns*sizeof(double));
  244.  
  245.         int id, i, j;
  246.         int  nSum = 0; // point with U>0, V>0
  247.         for (id=0; id < nPoints; id++ )
  248.         {
  249.             pfu[id] = pfU[id] / dU;
  250.             nSum++;
  251.         }
  252.  
  253.         for (i=0; i <= nAppr; i++ )//equation coeffs
  254.         {
  255.             for (j=0; j <= nAppr+1; j++ )  aa(i,j) = 0.;
  256.  
  257.             for (id=0; id < nPoints; id++ )
  258.             {
  259.                 double  u = pfU[id],
  260.                         v;
  261.                 if  (u != fU0)
  262.                 {
  263.                     v = (pfV[id] - fV0) / pow(u-fU0, fPoli);
  264.                     for (j=0; j <= nAppr; j++ )
  265.                         aa(i, j) += (pfW[id] * PowInt(pfu[id], i+j));
  266.  
  267.                     aa(i, nAppr+1) += (pfW[id] * PowInt(pfu[id], i) * v);
  268.                 }
  269.             } 
  270.         }
  271.         CalcEquGauss(nAppr, pfs, pfu);
  272.         for (i=0; i<= nAppr; i++ )
  273.         {
  274.             fAppr[i] = pfu[i] / PowInt(dU, i);
  275.         }
  276.  
  277.         nResult         = N_FACTORS;
  278.         
  279.         pfFactors[0] = nSum;
  280.         pfFactors[1] = fMinU; pfFactors[2] = fMaxU; // Unused now - reserved
  281.         pfFactors[3] = fMinV; pfFactors[4] = fMaxV; // Unused now - reserved
  282.         pfFactors[4] = 0; // Unused now - reserved
  283.         pfFactors[5] = fU0;
  284.         pfFactors[6] = fV0;
  285.         pfFactors[7] = fPoli;
  286.         pfFactors[8] = nAppr;
  287.         for (i=0; i<=nAppr; i++)
  288.             pfFactors[9+i] = fAppr[i];
  289.     
  290.         pfFactors[N_FACTORS-1] = CalcError(pfU, pfV, nPoints, pfFactors, nFactors); 
  291.  
  292.     delete [] pfu;
  293.     delete [] pfs;
  294.     
  295.     return nResult;
  296. }
  297.  
  298.  
  299.  
  300.  
  301. // Calculate value V = Function(fU)
  302. // Input:
  303. //        fU
  304. //        pfFactors - array of factors, prepared in finction Prepare()
  305. //      pnFactors: - number of factors in array 
  306. //
  307. // return: value calculated
  308. //
  309. double __declspec(dllexport) __stdcall CalcInPoint(double fU, 
  310.                                          double *pfFactors, int nFactors)
  311. {
  312.     if (nFactors < N_FACTORS)
  313.         return  0.;
  314.     double 
  315.             U     = fU,
  316.             U0    = pfFactors[5],
  317.             V0    = pfFactors[6],
  318.              fPoli = pfFactors[7];
  319.     int nAppr = (int)pfFactors[8];
  320.  
  321.     if (fPoli <-5) fPoli =-5;
  322.     if (fPoli > 5) fPoli = 5;
  323.     if (nAppr < 0) return 0.;
  324.  
  325.     double f = 1.,
  326.            fV= 0.;
  327.     for (int i=0; i<=nAppr; i++)
  328.     {
  329.         fV += f*pfFactors[9+i];
  330.         f *= U;
  331.     }
  332.  
  333.     fV = V0 + fV * pow(U-U0, fPoli);
  334. //    fV = V0 + (U-U0)*(A0 + A1*U);
  335. //    fV = (A0 + A1*U + A2*U*U);
  336.     return fV;
  337. }
  338.  
  339. // Fill information string with name of approximation method
  340. // It is used in FindGraph <Master of approximations page 2><list of user defined functions>
  341. // for example - "User's poli_n"
  342. // Input:
  343. //        pstr - buffer TCHAR
  344. //      nMaxLength - maximum buffer length
  345. //
  346. // Output:
  347. //        pstr - name of approximation method
  348. //
  349. // return: string length if success, else -1
  350. //
  351. int __declspec(dllexport) __stdcall FunctionTitle(LPTSTR pstr, int nMaxLength) 
  352. {
  353.     if (pstr==0)
  354.         return -1;
  355.     lstrcpyn(pstr, TEXT(" y = V0 + (x-U0)^M *(A0 + A1*x...+AN*x^N)"), nMaxLength);
  356.     return lstrlen(pstr);
  357. }
  358.  
  359.  
  360.  
  361. // Fill information string with name of approximation function
  362. // for example - "V(U) = V0 + Exp(a*(U-U0))*Pow((U-U0), b)"
  363. // It is used in FindGraph <Master of approximations page 3><Function description>
  364. // Input:
  365. //        pstr - buffer TCHAR
  366. //      nMaxLength - maximum buffer length
  367. //
  368. // Output:
  369. //        pstr - name of approximation function
  370. //
  371. // return: string length if success, else -1
  372. //
  373. int __declspec(dllexport) __stdcall FunctionName(LPTSTR pstr, int nMaxLength) 
  374. {
  375.     if (pstr==0)
  376.         return -1;
  377.     lstrcpyn(pstr, TEXT("f(U) = V0 + (U-U0)^M *(A0+...+AN*U^N)"), nMaxLength);
  378.     return lstrlen(pstr);
  379. }
  380.  
  381.  
  382.  
  383. // Fill information string with formula of calculated function f(U) = Formula()
  384. // It is used in FindGraph <Master of approximations pages 4 and 5>
  385. // Input:
  386. //        pstr - buffer TCHAR
  387. //      nMaxLength - maximum buffer length
  388. //        pfFactors - array of factors, prepared in finction Prepare()
  389. //      pnFactors: - number of factors in array 
  390. //
  391. // Output:
  392. // pstr - string of calculated function f(U)
  393. //
  394. // return: string length if success, else -1
  395. //
  396. int __declspec(dllexport) __stdcall FunctionString(double *pfFactors, int nFactors,
  397.                                          LPTSTR pstr, int nMaxLength) 
  398. {
  399.     if (pstr==0)
  400.         return -1;
  401.     if (nFactors < N_FACTORS)
  402.         return -2;
  403.  
  404.     TCHAR  sz[256];
  405.     double 
  406.             U0     = pfFactors[5],
  407.             V0     = pfFactors[6],
  408.              fPoli= pfFactors[7],
  409.             fA[10];
  410.  
  411.     int  nAppr = (int)pfFactors[8];
  412.     if  (nAppr>=0)
  413.     for (int i=0; i<=nAppr; i++)
  414.     {
  415.         fA[i] = pfFactors[9+i];
  416.     }
  417.  
  418.  
  419. //    sprintf(sz, TEXT("f(U) = %4.4g + (U-%4.4g)*(%4.4g + %4.4g*U + %4.4g*U2)"),V0, U0, A0, A1, A2);
  420. //    sprintf(sz, TEXT("f(U) = %4.4g + (U-%4.4g)*(%4.4g + %4.4g*U)"),V0, U0, A0, A1);
  421.     TCHAR sz1[24], sz2[24],
  422.           sza[256]; lstrcpy(sza, TEXT(""));
  423.  
  424.     if  (nAppr>=0)
  425.     for (int i=0; i<=nAppr; i++)
  426.     {
  427.         TCHAR szn[24]; 
  428.         sprintf(szn, TEXT("%4.4g"), fA[i]);
  429.         if (fA[i] > 0. && i)
  430.             lstrcat(sza, "+");
  431.         if (fA[i] != 0.)
  432.         {
  433.             lstrcat(sza, szn);
  434.             sprintf(szn, TEXT("*U^%1d"), i);
  435.             if (i)
  436.                 lstrcat(sza, szn);
  437.         }
  438.     }
  439.  
  440.     if (V0 != 0) sprintf(sz1, "%4.4g + ", V0);
  441.     else         lstrcpy(sz1, TEXT(""));
  442.  
  443.     if (U0 != 0) sprintf(sz2, "(U-%4.4g)", U0);
  444.     else         lstrcpy(sz2, TEXT("U"));
  445.  
  446.     if (fPoli==1) // default
  447.         sprintf(sz, TEXT("f(U) = %s%s * (%s)"),sz1, sz2, sza);
  448.     else
  449.         sprintf(sz, TEXT("f(U) = %s%s^%3.1f * (%s)"),sz1, sz2, fPoli, sza);
  450.  
  451. //TCHAR szz[64]; sprintf(szz,"\nM=%d N=%d",(int)fPoli, nAppr); lstrcat(sz, szz);    
  452.  
  453.     lstrcpyn(pstr, sz, nMaxLength);
  454.     return lstrlen(pstr);
  455. }
  456.  
  457.  
  458.  
  459. // Fill information string with name of parameter and it's default value
  460. // It is used in FindGraph <Master of approximations page 3>
  461. // Input:
  462. //      nParam - number of edit box in page 3
  463. //                 1, 2, 3, 4
  464. //               see list of pfParams in function 'Prepare'
  465. //        pstr - buffer TCHAR
  466. //      nMaxLength - maximum buffer length
  467. //
  468. // Output:
  469. //        pstr - name of parameter[nParam]
  470. //      pfDefault - default value of parameter[nParam]
  471. //
  472. // return: string length if success, else -1
  473. //
  474. int __declspec(dllexport) __stdcall ParamInfo(int nParam, LPTSTR pstr, int nMaxLength, double *pfDefault) 
  475. {
  476.     if (pstr==0)
  477.         return -1;
  478.     switch (nParam)
  479.     {
  480.         case 1: 
  481.             lstrcpyn(pstr, TEXT("M"), nMaxLength);
  482.             if (pfDefault != NULL)
  483.                *pfDefault = 1.;
  484.             break;
  485.         case 2: 
  486.             lstrcpyn(pstr, TEXT("N"), nMaxLength);
  487.             if (pfDefault != NULL)
  488.                *pfDefault = 4.;
  489.             break;
  490.         case 3: 
  491.             lstrcpyn(pstr, TEXT("U0"), nMaxLength);
  492.             if (pfDefault != NULL)
  493.                *pfDefault = 0.;
  494.             break;
  495.         case 4: 
  496.             lstrcpyn(pstr, TEXT("V0"), nMaxLength);
  497.             if (pfDefault != NULL)
  498.                *pfDefault = 0.;
  499.             break;
  500.         default: return -1;
  501.     }
  502.     return lstrlen(pstr);
  503. }
  504.